// 请求工具类
import { getBaseUrl, config } from './config.js'

const TOKEN_KEY = 'access_token'

// 保存token
export const setToken = (token) => {
  uni.setStorageSync(TOKEN_KEY, token)
}

// 获取token
export const getToken = () => {
  return uni.getStorageSync(TOKEN_KEY)
}

// 清除token
export const removeToken = () => {
  uni.removeStorageSync(TOKEN_KEY)
}

// 请求拦截器
export const request = (options) => {
  return new Promise((resolve, reject) => {
    // 获取基础URL
    const baseURL = getBaseUrl()
    const token = getToken()
    const header = {
      'Content-Type': 'application/json'
    }
    
    // 如果有token，添加到Authorization头
    if (token) {
      header.Authorization = token
      console.log('当前请求携带的token:', token)
    } else {
      console.log('当前请求没有token')
      // 开发环境才使用测试token
      if (process.env.NODE_ENV === 'development') {
        header.Authorization = 'Bearer dev_token_for_testing'
      }
    }

    // 处理URL和params参数
    let url = options.url
    // 添加baseURL前缀，如果URL不是以http开头
    if (!url.startsWith('http')) {
      url = baseURL + '/' + url
    }
    
    // 确保URL使用HTTPS
    // #ifdef MP-WEIXIN
    if (url.startsWith('http://')) {
      // url = url.replace('http://', 'https://')
      url = url.replace('http://', 'http://')
    }
    // #endif
    
    if (options.params && Object.keys(options.params).length > 0) {
      const queryString = Object.entries(options.params)
        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
        .join('&')
      url = `${url}${url.includes('?') ? '&' : '?'}${queryString}`
    }

    // 请求时间戳，用于计算请求时间
    const requestTimestamp = Date.now()
    
    // 打印请求信息（仅在开发环境）
    if (process.env.NODE_ENV === 'development') {
      console.log('请求URL:', url)
      console.log('请求方法:', options.method || 'GET')
      console.log('请求数据:', options.data)
    }
    
    uni.request({
      url: url,
      method: options.method || 'GET',
      data: options.data,
      header,
      timeout: config.timeout || 30000, // 使用配置中的超时时间
      success: (res) => {
        // 计算请求耗时
        const responseTime = Date.now() - requestTimestamp
        
        // 在开发环境下打印响应信息
        if (process.env.NODE_ENV === 'development') {
          console.log(`请求耗时: ${responseTime}ms`)
          console.log('响应数据:', res.data)
        }
        
        // 处理各种状态码
        if (res.statusCode === 401) {
          // 身份验证失败
          handleAuthError()
          reject(new Error('登录已过期，请重新登录'))
          return
        } else if (res.statusCode === 403) {
          // 权限不足
          uni.showToast({
            title: '您没有权限执行此操作',
            icon: 'none'
          })
          reject(new Error('权限不足'))
          return
        } else if (res.statusCode >= 500) {
          // 服务器错误
          uni.showToast({
            title: '服务器异常，请稍后再试',
            icon: 'none'
          })
          reject(new Error('服务器异常'))
          return
        } else if (res.statusCode !== 200) {
          // 其他错误
          uni.showToast({
            title: res.data?.message || '请求失败',
            icon: 'none'
          })
          reject(new Error(res.data?.message || '请求失败'))
          return
        }
        
        // 检查业务状态码
        if (res.data && res.data.code !== undefined && res.data.code !== 200) {
          uni.showToast({
            title: res.data.message || '操作失败',
            icon: 'none'
          })
          reject(new Error(res.data.message || '操作失败'))
          return
        }
        
        resolve(res.data)
      },
      fail: (err) => {
        handleRequestError(err)
        reject(new Error(getErrorMessage(err)))
      }
    })
  })
}

// 处理授权错误
function handleAuthError() {
  // 避免重复跳转登录页面
  const lastAuthErrorTime = uni.getStorageSync('last_auth_error_time')
  const currentTime = Date.now()
  
  if (!lastAuthErrorTime || (currentTime - lastAuthErrorTime > 3000)) {
    uni.setStorageSync('last_auth_error_time', currentTime)
    
    removeToken()
    uni.showToast({
      title: '登录已过期，请重新登录',
      icon: 'none',
      duration: 2000
    })
    
    setTimeout(() => {
      uni.navigateTo({
        url: '/pages/login/login'
      })
    }, 1500)
  }
}

// 处理请求错误
function handleRequestError(err) {
  console.error('请求失败:', err)
  
  // 网络连接问题特殊处理
  if (err.errMsg && (
    err.errMsg.includes('Failed to fetch') || 
    err.errMsg.includes('网络请求失败') ||
    err.errMsg.includes('request:fail')
  )) {
    uni.showToast({
      title: '网络连接失败，请检查您的网络',
      icon: 'none',
      duration: 3000
    })
  } else {
    uni.showToast({
      title: getErrorMessage(err),
      icon: 'none',
      duration: 3000
    })
  }
}

// 提取错误信息
function getErrorMessage(err) {
  if (err.errMsg) {
    return err.errMsg
  } else if (err.message) {
    return err.message
  } else if (typeof err === 'string') {
    return err
  }
  return '请求失败'
}

export default request 